%    Copyright (C) 1994, 2000 Aladdin Enterprises.  All rights reserved.
% 
% This software is provided AS-IS with no warranty, either express or
% implied.
% 
% This software is distributed under license and may not be copied,
% modified or distributed except as expressly authorized under the terms
% of the license contained in the file LICENSE in this distribution.
% 
% For more information about licensing, please refer to
% http://www.ghostscript.com/licensing/. For information on
% commercial licensing, go to http://www.artifex.com/licensing/ or
% contact Artifex Software, Inc., 101 Lucas Valley Road #110,
% San Rafael, CA  94903, U.S.A., +1(415)492-9861.

% $Id: pdf_main.ps 6681 2006-03-23 19:32:06Z ray $
% pdf_main.ps
% PDF file- and page-level operations.

/.setlanguagelevel where { pop 2 .setlanguagelevel } if
.currentglobal true .setglobal
/pdfdict where { pop } { /pdfdict 100 dict def } ifelse
pdfdict begin

% Patch in an obsolete variable used by some third-party software.
/#? false def

% Test whether the current output device handles pdfmark.
/.writepdfmarkdict 1 dict dup /pdfmark null put readonly def
/.writepdfmarks {	% - .writepdfmarks <bool>
  currentdevice //.writepdfmarkdict .getdeviceparams
  mark eq { false } { pop pop true } ifelse
  systemdict /DOPDFMARKS known or 
} bind def

% For simplicity, we use a single interpretation dictionary for all
% PDF graphics execution, even though this is too liberal.
/pdfopdict mark
  objopdict { } forall
  drawopdict { } forall
  /endstream { exit } bind
  (%%EOF) cvn { exit } bind		% for filters
	% PDF 1.1 operators
  /BX { /BXlevel BXlevel 1 add store } bind
  /EX { /BXlevel BXlevel 1 sub store } bind
  /PS { cvx exec } bind
	% PDF 1.2 operators
  /BMC { pop } bind
  /BDC { pop pop } bind
  /EMC { }
  /MP { pop } bind
  /DP { pop pop } bind
.dicttomark readonly def

% ======================== Main program ======================== %

end			% pdfdict
userdict begin

/defaultfontname /Times-Roman def

% Make sure the registered encodings are loaded, so we don't run the risk
% that some of the indices for their names will overflow the packed
% representation.  (Yes, this is a hack.)
SymbolEncoding pop
DingbatsEncoding pop

% Redefine 'run' so it recognizes PDF files.
systemdict begin
/.runps /run load def
/run {
  dup type /filetype ne { (r) file } if
  % skip leading whitespace characters (actually anything less than or equal to <sp>)
  { dup ( ) .peekstring not { false exit } if
    dup 0 get 32 le { pop dup read pop pop } { true exit } ifelse
  } loop
  {
    (%) eq {
      dup (     ) .peekstring {
	(%PDF-) eq {
	    dup (%stdin) (r) file eq {
	      % Copy PDF from stdin to temporary file then run it.
	      null (w+) //systemdict /.tempfile get exec exch 3 1 roll
	      % stack: tempname stdin tempfile
	      64000 string
	      {
		% stack: tempname stdin tempfile string
		2 index 1 index readstring
		exch 3 index exch writestring
		not { exit } if
	      }
	      loop
	      pop exch closefile
	      % stack: tempname tempfile
	      dup 0 setfileposition
	      dup runpdf
	      closefile deletefile
	    } {
	      runpdf
	    } ifelse
	  } {
	    cvx .runps % doesn't start with %PDF-
	  } ifelse
	} {
	  pop cvx .runps % didn't read 5 characters
	} ifelse
    } {
      cvx .runps % didn't start with %
    } ifelse
  } {
    pop closefile % file was empty
  } ifelse
} bind odef
currentdict /runpdfstring .undef


/runpdfbegin {		% <file> runpdf -
   userdict begin
	% It turns out that the PDF interpreter uses memory more
	% effectively if it is run under at least one level of save.
	% This is counter-intuitive, and we don't understand why it happens,
	% but the improvement is significant.
   /PDFTopSave save def
   0 setobjectformat
   /Page# null def
   /Page null def
   /DSCPageCount 0 def
   /PDFSave null def
   GS_PDF_ProcSet begin
   pdfdict begin
   pdfopen begin
   Trailer /Root oget /Pages oget /CropBox knownoget
    { oforce_array normrect mark /CropBox 3 -1 roll /PAGES pdfmark
    }
   if
   /FirstPage where 
    { pop FirstPage dup pdfpagecount gt
      { (\nRequested FirstPage is greater than the number of pages in the file: ) print
        pdfpagecount = flush
      } if
    } {
      1
    } ifelse
   /LastPage where { pop LastPage pdfpagecount .min } { pdfpagecount } ifelse
   1 index 1 index gt
    { (   No pages will be processed \(FirstPage > LastPage\).) = flush }
    { QUIET not
      { (Processing pages ) print 1 index =only ( through ) print dup =only
        (.) = flush
      }
     if
    }
   ifelse
} bind def

/dopdfpages {   % firstpage# lastpage# dopdfpages -
  << /PDFScanRules true >> setuserparams	% set scanning rules for PDF vs. PS
  true .setaccuratecurves			% unlike PS, PDF seems to need this
  1 exch
    { dup /Page# exch store
      QUIET not { (Page ) print dup == flush } if
      pdfgetpage pdfshowpage
    } for
  false .setaccuratecurves			% restore accuratecurves behaviour
  << /PDFScanRules null >> setuserparams	% restore scanning rules for PS
} bind def

/runpdfend {
   Repaired { printrepaired } if
   currentdict pdfclose
   end			% temporary dict
   end			% pdfdict
   end			% GS_PDF_ProcSet
   PDFTopSave restore
   end			% userdict
   2 vmreclaim		% couldn't hurt
} bind def

/runpdf {		% <file> runpdf -
  runpdfbegin
  dopdfpages
  runpdfend
} bind def

end			% systemdict
% Redefine the procedure that the C code uses for running piped input.
% It is OK to use { (%stdin) run } here, because a startjob cannot occur.
/.runstdin {
  { (%stdin) run } execute0
} bind def

end			% userdict
pdfdict begin

% ======================== File parsing ======================== %

% Read the cross-reference and trailer sections.

/traileropdict mark
  (<<) cvn { mark } bind
  (>>) cvn { { .dicttomark } stopped {
	      (   **** File has unbalanced >> in trailer.\n) pdfformaterror
             } if } bind
  ([) cvn { mark } bind		% ditto
  (]) cvn dup load
%  /true true		% see .pdfexectoken in pdf_base.ps
%  /false false		% ibid.
%  /null null		% ibid.
  /R { /resolveR cvx 3 packedarray cvx } bind	% see Objects below
  /startxref /exit load
.dicttomark readonly def

% Because of EOL conversion, lines with fixed contents might be followed
% by one or more blanks.
/lineeq			% <filestr> <conststr> lineeq <bool>
 { anchorsearch
    { pop { ( ) anchorsearch not { () eq exit } if pop } loop }
    { pop false }
   ifelse
 } bind def
/linene { lineeq not } bind def

 %  Read original version (pre PDF 1.5) of the xref table.
 %  Note:  The position is the location of 'xref'.  The current PDFfile
 %  position is just after the 'XREF'.
/readorigxref		% <pos> readorigxref <trailerdict>
 {
   pop				% We do not need the position.
   0				% Initialize xref table error counter
   { PDFfile token pop		% first object # or trailer
     dup /trailer eq { pop exit } if
     PDFfile pdfstring readline pop
     token pop			% entry count
     % remaining must be whitespace only (otherwise this xref Size was invalid.
     exch dup length 0 ne {
       false 1 index { 32 gt { pop true exit } if } forall {
         (   **** Warning: xref subsection header has extra characters.\n)
         pdfformaterror
         /setxrefentry cvx /syntaxerror signalerror
       } if
     } if
     pop			% remove last
		% This section might be adding new objects:
		% ensure that Objects and Generations are big enough.
		% stack: <err count> <first obj> <entry count>
     2 copy add growPDFobjects
     {				% stack: <err count> <obj num>
		% Read xref line
       PDFfile 20 string readstring pop  % always read 20 chars.
       token pop		% object position
       exch token pop		% generation #
       exch token pop		% n or f
       exch			% stack: <err count> <obj#> <loc> <gen#> <tag> <remainder of line>
       dup length 0 ne {
         % check to make sure trailing garbage is just white space
	 dup { 32 gt { 5 -1 roll 1 add 5 1 roll } if } forall   % bump error count on garbage
       } if
       pop			% Stack: <err count> <obj#> <loc> <gen#> <tag>
       dup /n eq {		% xref line tag is /n
	 pop			% pop dup of line tag
         Objects 3 index lget null eq {	% later update might have set it
	   0 3 1 roll		% Set ObjectStream object number = 0
	   setxrefentry		% Save xref entry
	   3 -1 roll pop	% Remove ObjectStream object onumber
         } if
       }
       {			% xref line tag was not /n
	 /f ne			% verify that the tag was /f
         { /setxrefentry cvx /syntaxerror signalerror
	 } if
       } ifelse
       pop pop			% pop <obj location> and <gen num>
       % stack: <err count> <obj num>
       1 add			% increment object number
     } repeat
     pop			% pop <obj #>
   } loop
   0 ne {
     (   **** Warning:  length of some xref entries is not equal to 20 bytes.\n)
     pdfformaterror
   } if
   PDFfile traileropdict .pdfrun
 } bind def

 % This dicitonary is used to read the xref dictionary.  It should work for
 % reading any dictionary.  dictlevelcount must contain 0.
/xrefopdict mark
  (<<) cvn { /dictlevelcount dictlevelcount 1 add def mark } bind
  (>>) cvn { .dicttomark /dictlevelcount dictlevelcount 1 sub def
  	     dictlevelcount 0 eq { exit} if } bind
  ([) cvn { mark } bind		% ditto
  (]) cvn dup load
%  /true true		% see .pdfexectoken in pdf_base.ps
%  /false false		% ibid.
%  /null null		% ibid.
  /R { /resolveR cvx 3 packedarray cvx } bind	% see Objects below
.dicttomark readonly def

% Get a variable length positive integer value from a stream.  A value
% of zero is returned if the count is zero.
/getintn {	% <stream> <count> getintn int
  0 exch { 256 mul 1 index read pop add } repeat
  exch pop			% Discard stream
} bind def

% This array contains handlers for processing the different types of
% entries in the XRef stream.
% Stack: <Xrefdict> <xref stream> <Index array> <pair loc> <obj num>
% 	 <field 2> <field 3>
% The handlers leave the stack unchanged.
/xref15entryhandlers [
  {	% XRef entry type 0 - free or f type xref entry
%    (free ) print
%    (obj num: ) print 2 index pdfstring cvs print ( ) print
%    (loc: ) print 1 index pdfstring cvs print ( ) print
%    (gen: ) print dup === flush
  } bind		% Do nothing for free xref entries
	% XRef entry type 1 - normal or n type xref entry
  {	% field 2 = obj loc, field 3 = gen num
%    (normal ) print
%    (obj num: ) print 2 index pdfstring cvs print ( ) print
%    (loc: ) print 1 index pdfstring cvs print ( ) print
%    (gen: ) print dup === flush
    0 3 1 roll			% set stream number = 0
    setxrefentry
    3 -1 roll pop		% remove stream number
  } bind
	% XRef entry type 2 - compressed object type xref entry
  {	% field 2 = object stream num, field 3 = index into object stream
%    (Compressed objects: ) print
%    (obj num: ) print 2 index pdfstring cvs print ( ) print
%    (field 2: ) print 1 index pdfstring cvs print ( ) print
%    (field 3: ) print dup === flush
    0 setxrefentry pop		% set generation number = 0
  } bind
] def

 %  Read the PDF 1.5 version of the xref table.
 %  Note:  The position is the location of the start of the dictionary object
 %  In PDF 1.5, the XRef dictionary also serves as the trailer dictionary
/readpdf15xref		% <pos> readpdf15xref <trailerdict>
 {
   PDFfile exch setfileposition		% move to start of object
   	% Get object number, revision, and 'obj' and discard
   PDFfile token pop pop
   PDFfile token pop pop
   PDFfile token pop pop
	% Get the XRef dicitionary
   /dictlevelcount 0 def PDFfile xrefopdict .pdfrun
	% Verify that we have an XRef dictionary
   dup /Type get /XRef ne {
     /readpdf15xref cvx /syntaxerror signalerror
   } if
   	% Ensure that we we have room in the objects array, etc.
   dup /Size get growPDFobjects
	% Create a stream for the XRef data
   PDFfile token pop pop		% Skip over 'stream'
   dup stream false resolvestream
   	% Stack: <XRefdict> <xref stream>
	% The Index array defines the ranges of object numbers in the
	% XRef stream.  Each value pair is consists of starting object
	% number and the count of consecutive objects.
	% Get the Index array, if present
   1 index /Index .knownget not {	% If no Index array ...
     [ 0 3 index /Size get ]		% Default = [ 0 Size ]
   } if
	% Loop through the Index array
   0 2 2 index length 1 sub {
	% Get start and end of object range
     2 copy get				% Start of the range
     dup 3 index 3 index 1 add get 	% Number of entries in range
     	% Loop through the range of object numbers
     add 1 sub 1 exch {			% Form end of range, set increment = 1
	% Stack: <Xrefdict> <xref stream> <Index array> <pair loc> <obj num>
	% Get xref parameters.  Note:  The number of bytes for each parameter
	% is defined by the entries in the W array.
       4 index /W get aload pop		% Get W array values
       	% The first field indicates type of entry.  Get first field value.
	% If the num. of bytes for field 1 is 0 then default field value is 1
       3 -1 roll dup 0 eq { pop 1 } { 6 index exch getintn } ifelse
	% Get the handler for the xref entry type.  We will execute the
	% handler after we get the other two field values.
       xref15entryhandlers exch get
       3 -1 roll 6 index exch getintn	% Get second field
       3 -1 roll 6 index exch getintn	% Get third field
       3 -1 roll exec			% Execute Xref entry handler
       pop pop pop			% Remove field values and obj num
     } for				% Loop through Xref entries
     pop				% Remove Index array pair loc
   } for				% Loop through Index array entries
   pop pop				% Remove Index array and xref stream
 } bind def

% Read the cross-reference table.
% <pos> is the position either from the startxref statement or the /Prev
% entry in the prior trailer dictionary.
/readxref		% <pos> readxref <trailerdict>
 {
   PDFoffset add PDFfile exch setfileposition
		% In some PDF files, this position actually points to
		% white space before the xref line.  Skip over this here.
   {
     PDFfile fileposition PDFfile read pop 32 gt { exit } if pop
   } loop
   dup		% Make copy of the file position (before last char was read).
   PDFfile exch setfileposition
		% The PDF specification says that the 'xref' must be on a line
		% by itself. The code here formerly used readline and linene to
		% check this. However, Acrobat Reader only requires the line to
		% begin with 'xref', and there are enough applications producing
		% non-compliant PDF files that we have to do this too.
   PDFfile pdfstring 0 4 getinterval readstring pop
   (xref) eq
   { readorigxref } 	% 'xref' -> original xref table
   { readpdf15xref }	% otherwise assume PDF 1.5 xref stream
   ifelse
 } bind def

% Open a PDF file and read the header, trailer, and cross-reference.
/pdfopen {		% <file> pdfopen <dict>
	% Color space substitution in PDF is handled somewhat differently
	% than in PostScript. A given device color space will be substituted
	% if the corresponding "Default..." entry exists in the Page's
	% Resource dictionary (which might be inhereted); there is no
	% UseCIEColor to enable/disable color mapping.
	%
	% This behavior is achieved by always setting UseCIEColor to true
	% in the page device dictionary. If the value of this parameter was
	% originally false (i.e.: the output device does not perform color
	% space substitution by default), the instances DefaultGray,
	% DefaultRGB, and DefaultCMYK of the (local) ColorSpace category
	% are redefined to be DeviceGray, DeviceRGB, and DeviceCMYK,
	% respectively. This is not done if UseCIEColor is true by default,
	% as in that case color substitution is presumably desired even
	% if the file does not request it.
   currentpagedevice /UseCIEColor .knownget dup { pop } if not
    { .currentglobal false .setglobal
      /DefaultGray { /DeviceGray } cvlit /ColorSpace defineresource pop
      /DefaultRGB { /DeviceRGB } cvlit /ColorSpace defineresource pop
      /DefaultCMYK { /DeviceCMYK } cvlit /ColorSpace defineresource pop
      .setglobal
    }
   if
  pdfopenfile begin
  pdfopencache
  .writepdfmarks {
	% Copy bookmarks (outline) to the output.
    Trailer /Root oget /Outlines knownoget {
      /First knownoget {
	{ dup writeoutline /Next knownoget not { exit } if } loop
      } if
    } if
  } if		% end .writepdfmarks
  currentdict end
} bind def

% Verify that each entry in the xref table is pointing at an object with
% the correct object number and generation number.
/verify_xref				% - verify_xref -
{ PDFfile dup 0 setfileposition bytesavailable	% Determine the size of the file
  1 1 Objects llength 1 sub	% stack: filesize 1 1 <number of objects - 1>
  {	% Check if the object is free (i.e. not used).  The values in
	% Generations is the generation number plus 1.  If the value in
	% Generations is zero then the object is free.
	% Stack:  <filesize> <obj num>
    Generations 1 index lget 		% Get the genration number
    0 ne {				% Skip if object number is free
      ObjectStream 1 index lget 	% Check if object is in objectstream
      0 eq {	% We only check objects not in an objectstream
        {	% Use stop context since we may get an error if object is invalid
          dup Objects exch lget 	% Get the object location
	  PDFoffset add dup 3 index ge	% Compare object location to file size
	  { pop true }			% Rebuild if location not in file
	  { PDFfile exch setfileposition % Go to the object location
	    true			% Stack:  <filesize> <obj num> <true>
	    PDFfile token pop		% Read object number from file
	    2 index eq {		% Verify object number
	      PDFfile token pop		% Read generation number from file
	      Generations 3 index	% Get specified generaton number
	      lget 1 sub		% Gen numbs are stored with 1 added.
	      eq { 			% Verify generation number
	        PDFfile token pop
	        /obj eq { % Verify 'obj' text
		  pop false		% We have valid object, do not rebuild
	        } if
	      } if
	    } if
	  } ifelse
	} .internalstopped
	{ true } if			% If we stop then we need to rebuild
	% Stack:  <filesize> <obj num> <need rebuild flag>
	{ 
	  (   **** Warning:  File has an invalid xref entry:  )
	  pdfformaterror
	  pdfstring cvs pdfformaterror
	  (.  Rebuilding xref table.\n) pdfformaterror
	  search_objects
	  exit
	} if				% If the entry is invalid
      } if				% If not in an object stream
    } if				% If object entry is not free
    pop					% Remove object number
  } for
  pop					% Remove the size of the file
} bind odef

/pdfopencache {		% - pdfopencache -
	% Create and initialize some caches.
  /PageCount pdfpagecount def
  /PageNumbers PageCount 65534 .min dict def
  /PageIndex PageCount 65534 .min array def
} bind def

/pdfopenfile {		% <file> pdfopenfile <dict>
   pdfdict readonly pop		% can't do it any earlier than this
   15 dict begin
   /LocalResources 0 dict def
   /DefaultQstate //null def	% establish binding
   /Printed where { pop } {
		% Guess whether the output device is a printer.
     /Printed currentpagedevice /OutputFile known def
   } ifelse
   /PSLevel1 where { pop } { /PSLevel1 false def } ifelse
   % NB: PDFfile is used outside of the PDF code to determine that a
   % PDF job is being processed; to not change or hide this key.
   cvlit /PDFfile exch def
   /PDFsource PDFfile def
   /Repaired false def
   currentglobal true .setglobal globaldict begin
   /TTFWarnList 0 dict def /UndefProcList 0 dict def
   end .setglobal
   PDFfile dup 0 setfileposition pdfstring readstring 
   not {/pdfopen cvx /syntaxerror signalerror} if
   (%PDF-) search not {/pdfopen cvx /syntaxerror signalerror} if
   length /PDFoffset exch def pop
   % some badly formed PDF's (Visioneer) have something other than EOL
   % after the version number. If we get an error, shorten the string
   % and try again.
   false exch		% error encountered
   { { cvr } stopped
     { exch pop true exch 0 1 index length 1 sub dup 0 eq
       { pop 0 exit } if	% exit if string now empty
       getinterval		% trim character from right end and retry
     }
     { exch {
         (   **** Warning: PDF version number not followed by EOL.\n)
         pdfformaterror
       }
       if exit
     }
     ifelse
   } loop

   /PDFversion exch def
	% Read the last cross-reference table.
   count /pdfemptycount exch def
   /Trailer << >> def		% Initialize to an emptry dict.
   { initPDFobjects findxref readxref } .internalstopped {
     recover_xref_data		% Read failed.  Attempt to recover xref data.
     search_trailer		% Search for the primary trailer
   } {
     /Trailer exch def		% Save trailer dict after first xref table
	% Read any previous cross-reference tables.  When we are done,
	% verify that the entries in the xref tables are valid if NoVerifyXref
	% is not defined.
     Trailer
     { /Prev knownoget not {	% If no previous xref table then ...
         /NoVerifyXref where { pop } { verify_xref } ifelse exit
       } if
       { readxref } .internalstopped {
         recover_xref_data	% Read failed.  Attempt to recover xref data.
	 exit			% Exit loop since recover gets all obj data.
       } if  			% If readxref stopped
       % The PDF spec. says that each trailer dict should contain the required
       % entries.  However we have seen a PDF file that only has a Prev entry in
       % the initial trailer dict.  Acrobat complains but it accepts these files.
       % To work with these files, we are copying any entries which we find in
       % a previous trailer dict which are not present in the initial dict.
       dup {
         Trailer 2 index known {
           pop pop              % discard if key already present
         } {
           Trailer 3 1 roll put % add key if not present
         } ifelse
       } forall
     } loop			% Loop to previous trailer
   } ifelse			% Ifelse readxref stopped
   Trailer /Encrypt knownoget {
     pop
     pdf_process_Encrypt	% signal error
   } if
   currentdict end
 } bind def

% Look for [\r\n]%%EO from the current position of the file.
% Return the position of %%EO if found or -1 .
/findeof {  % <file> find_eof <file> <position>
  -1 exch
  {
    dup bytesavailable 4 lt { exit } if
    dup 0 (%%EO) /SubFileDecode filter flushfile
    dup dup fileposition 5 sub setfileposition
    dup 5 string readstring not { pop exit } if
    dup (\r%%EO) eq exch (\n%%EO) eq or {
      dup fileposition 4 sub
      3 1 roll exch pop
    } if
  } loop
  exch
} bind def

% Skip backward over the %%EOF at the end of the PDF file, and read
% the preceding startxref line.  The PDF specification unambiguously
% requires that the %%EOF appear on a line by itself, and that the
% startxref and the following position value appear on separate lines;
% however, some applications truncate the %%EOF to %%EO, and/or put the
% startxref and the following value on the same line.
% There seems to be no limit on the amount of garbage that can be
% appended to the PDF file. Current record (60K) belongs to
% PDF-Out (v 2.0 - 35). We start the search for %%EO from the last 1024
% bytes and continue from the beginning of the file.
/findxref {		% - findxref <xrefpos>
  PDFfile dup dup dup 0 setfileposition bytesavailable
  dup /PDFfilelen exch def
	% Find the last %%EOF string (within 1024 bytes)
  1024 sub PDFoffset .max
  setfileposition findeof                  % search the last 1024 bytes
  dup 0 le {
    pop
    dup PDFoffset setfileposition findeof  % search from the beginnibg
    dup 0 le {
       (   **** Error: Cannot find a %%EOF marker anywhere in the file.\n)
       pdfformaterror
       /findxref cvx /syntaxerror signalerror
    } if
  } if
  dup 3 1 roll setfileposition
        % Stack: eofpos
	% Check for whether this is, in fact, a valid PDF file.
  dup PDFfilelen exch sub dup dup 7 gt exch 5 lt or {
    pop true
  } {
    string PDFfile exch readstring pop
    dup (%%EOF\n) eq exch dup (%%EOF\r) eq
    exch dup (%%EOF\r\n) eq exch (%%EOF) eq or or or not
  } ifelse {
    (   **** Warning: File has a corrupted %%EOF marker, or garbage after %%EOF.\n)
    pdfformaterror
  } if
  PDFfile exch setfileposition
	% Now read the startxref and xref start position.
  prevline token not { null } if dup type /integertype eq {
    exch pop cvi		% xref start position
    exch PDFfile exch setfileposition
    prevline dup (startxref) linene {
      % startxref not on a line by itself.  We have found PDF from
      % www.verypdf.com in which the startxref was on the same line as
      % the end of trailer dictionary.  Check for this.  Note:  This
      % violates the spec.
      dup (startxref) search {
	% found startxref - print warning
	pop pop pop 			% clear strings from search
        (   **** Warning: format of the startxref line in this file is invalid.\n)
        pdfformaterror
      } {				% no startxref - we have a problem.
        /findxref cvx /syntaxerror signalerror
      } ifelse
    } if
    pop pop
  } {	% else, this file has 'startxref #####' format
    (startxref) ne { /findxref cvx /syntaxerror signalerror } if
    cvi		% xref start position
    (   **** Warning: format of the startxref line in this file is invalid.\n)
    pdfformaterror
    exch PDFfile exch setfileposition
  } ifelse
} bind def
/stderrfile (%stderr) (w) file def
/stderrprint {                % <string> stderrprint -
  //stderrfile dup 3 -1 roll writestring flushfile
} bind def
/pdfformaterror {	% <string> pdfformaterror -
  stderrprint
  /Repaired true store
} bind def

/knownoget_safe
{ 2 copy knownoget { 3 1 roll pop pop //true } { pop pop //false } ifelse
} odef

/printProducer {
  Trailer /Info { knownoget_safe } stopped { pop pop false } if {
    /Producer knownoget not { null } if
  } {
    null
  } ifelse
  dup null eq {
    pop
  } {
    (   **** The file was produced by: \n   **** >>>> ) stderrprint
	% Handle a Unicode Producer.
    (\376\377) anchorsearch {
      pop dup length 2 idiv string 0 1 2 index length 1 sub {
		% Stack: origstr newstr i
	1 index exch 3 index 1 index 2 mul 1 add get put
      } for exch pop
    } if
    stderrprint
    ( <<<<\n) stderrprint
  } ifelse
} bind def
% The TTFWarnList is the list of all TrueType fonts that were not embedded.
% The UndefProcList collects noisy warnings.
% This gets rid of many multiple warnings from pdf_font.ps
/printCollectedWarnings {
   TTFWarnList length 0 gt {
      (\n   **** Warning: Fonts with Subtype = /TrueType should be embedded.\n)
      stderrprint
      (                 The following fonts were not embedded:\n)
      stderrprint
      [ TTFWarnList { pop .namestring (\t\t\t) exch concatstrings (\n) concatstrings } forall ] 
      { lt } .sort { stderrprint } forall
   } if
   UndefProcList length 0 gt {
      (\n   **** Embedded font uses undefined procedure\(s\):  ) stderrprint
      UndefProcList {
         exch .namestring stderrprint ( ) stderrprint
	 =string cvs stderrprint ( times, ) stderrprint
      } forall 
      (\n) stderrprint
   } if
} bind def
/printrepaired {
   printCollectedWarnings
   (\n   **** This file had errors that were repaired or ignored.\n)
  stderrprint
  printProducer
  (   **** Please notify the author of the software that produced this\n)
  stderrprint
  (   **** file that it does not conform to Adobe's published PDF\n)
  stderrprint
  (   **** specification.\n\n)
  stderrprint
} bind def

% Write the outline structure for a file.  Uses linkdest (below).
% omit links to pages that don't exist.
/writeoutline		% <outlinedict> writeoutline -
 { mark
   0 2 index /First knownoget
    { { exch 1 add exch /Next knownoget not { exit } if } loop }
   if
		% stack: dict mark count
   dup 0 eq
    { pop 1 index }
    { 2 index /Count knownoget { 0 lt { neg } if } if
      /Count exch 3 index
    }
   ifelse { linkdest } stopped 
    {
      cleartomark	% ignore this link
      (   **** Warning: Outline has invalid link that was discarded.\n)
      pdfformaterror
    } {
      /Title oget /Title exch /OUT pdfmark
    }
   ifelse
   /First knownoget
    { { dup writeoutline /Next knownoget not { exit } if } loop }
   if
 } bind def

% Close a PDF file.
/pdfclose		% <dict> pdfclose -
 { begin
   PDFfile closefile
   end
 } bind def

% ======================== Page accessing ======================== %

% Get a (possibly inherited) attribute of a page.
/pget			% <pagedict> <key> pget <value> -true-
			% <pagedict> <key> pget -false-
 {
   2 copy knownoget
    { exch pop exch pop true }
    { exch /Parent knownoget
      { exch pget }
	% finally see if the key is (misplaced) in the Root Catalog dict
      { dup Trailer /Root oget exch knownoget dup {
	  3 -1 roll (   **** Warning:  The /) pdfformaterror 50 string cvs pdfformaterror
	  ( key is missing from the Page tree.\n) pdfformaterror
        }
	{ exch pop }
	ifelse
      }
      ifelse
    }
   ifelse
 } bind def

% Get the value of a resource on a given page.
/rget {			% <resname> <pagedict> <restype> rget <value> -true-
			% <resname> <pagedict> <restype> rget -false-
  LocalResources 1 index knownoget {
     3 index knownoget
  } {
    false
  } ifelse {
    exch pop exch pop exch pop true
  } {
    exch /Resources pget {
      exch knownoget { exch knownoget } { pop false } ifelse
    } {
      pop pop false
    } ifelse
  } ifelse
} bind def

% Get the total number of pages in the document.
/pdfpagecount		% - pdfpagecount <int>
 { Trailer /Root oget /Pages oget
   dup /Count knownoget {
     exch pop
   } {
       dup /Type oget /Page eq {
         << exch 1 array astore /Kids exch /Count 1 /Type /Pages >>
         Trailer /Root oget /Pages 3 -1 roll put
         1
         (   **** Warning:  No /Pages node. The document root directly point a page.\n)
         pdfformaterror
     } {
       (   **** Warning:  Page count not found; assuming 1.\n)
       pdfformaterror
       pop 1 
     } ifelse
   } ifelse
 } bind def

% Find the N'th page of the document by iterating through the Pages tree.
% The first page is numbered 1.
/pdffindpageref {		% <int> pdffindpage <objref>
  dup Trailer /Root oget /Pages get
    {		% We should be able to tell when we reach a leaf
		% by finding a Type unequal to /Pages.  Unfortunately,
		% some files distributed by Adobe lack the Type key
		% in some of the Pages nodes!  Instead, we check for Kids.
      dup oforce /Kids knownoget not { exit } if
      exch pop null
      0 1 3 index length 1 sub {
         2 index exch get
	 dup oforce dup /Kids known { /Count oget } { pop 1 } ifelse
		% Stack: index kids null noderef count
	 dup 5 index ge { pop exch pop exit } if
	 5 -1 roll exch sub 4 1 roll pop
      } for exch pop
		% Stack: index null|noderef
      dup null eq { pop pop 1 null exit } if
    } loop
		% Stack: index countleft noderef
   1 index 1 ne { pop pop /pdffindpage cvx /rangecheck signalerror } if
   exch pop
   PageIndex 2 index 1 sub 65533 .min 2 index oforce put
   PageNumbers 1 index oforce 3 index dup 65534 le
    { put }
    { pop pop pop }	% don't store more than 65534 pagenumbers
   ifelse
   exch pop
} bind def
/pdffindpage {		% <int> pdffindpage <pagedict>
  pdffindpageref oforce
} bind def

% Find the N'th page of the document.
% The first page is numbered 1.
/pdfgetpage		% <int> pdfgetpage <pagedict>
 { PageIndex 1 index 1 sub dup 65533 lt
    { get }
    { pop pop null }
   ifelse
   dup null ne
    { exch pop oforce }
    { pop pdffindpage }
   ifelse
 } bind def

% Find the page number of a page object (inverse of pdfgetpage).
/pdfpagenumber		% <pagedict> pdfpagenumber <int>
 {	% We use the simplest and stupidest of all possible algorithms....
   PageNumbers 1 index .knownget
    { exch pop
    }
    { 1 1 PageCount 1 add	% will give a rangecheck if not found
       { dup pdfgetpage oforce 2 index eq { exit } if pop
       }
      for exch pop
    }
   ifelse
 } bind def

% Arrange the four elements that define a rectangle into a 'normal' order.
/normrect_elems   % <x1> <y1> <x2> <y2> normrect_elems <llx> <lly> <urx> <ury>
{
    exch 4 1 roll			% <x2> <x1> <y1> <y2>
    2 copy gt { exch } if		% <x2> <x1> <lly> <ury>
    4 2 roll 2 copy lt { exch } if	% <lly> <ury> <urx> <llx>
    4 1 roll exch			% <llx> <lly> <urx> <ury>
} bind def

% Arrange a rectangle into a 'normal' order.  I.e the lower left corner
% followed by the upper right corner.
/normrect 	% <rect> normrect <rect>
{
    aload pop normrect_elems 4 array astore
} bind def

/boxrect		% <llx> <lly> <urx> <ury> boxrect <x> <y> <w> <h>
 { exch 3 index sub exch 2 index sub
 } bind def
/resolvedest {		% <name|string|other> resolvedest <other|null>
  dup type /nametype eq {
    Trailer /Root oget /Dests knownoget {
      exch knownoget not { null } if
    } {
      pop null
    } ifelse
  } {
    dup type /stringtype eq {
      Trailer /Root oget /Names knownoget {
	/Dests knownoget {
	  exch nameoget
	} {
	  pop null
	} ifelse
      } {
	pop null
      } ifelse
    } if
  } ifelse
} bind def
/linkdest {		% <link|outline> linkdest
			%   ([/Page <n>] /View <view> | ) <link|outline>
  dup /Dest knownoget
    { resolvedest
      dup type /dicttype eq { /D knownoget not { null } if } if
      dup null eq
       { pop }
       { dup 0 oget
         dup type /dicttype eq {
           dup /Type knownoget {
             /Page eq {
               pdfpagenumber
             } if
           } if
         } if
         dup type /integertype ne 
           { pop }
           { /Page exch 4 -2 roll }
         ifelse
	 dup length 1 sub 1 exch getinterval /View exch 3 -1 roll
       }
      ifelse
    }
   if
} bind def
% <pagedict> mark ... -proc- -
/namedactions 8 dict dup begin
  /FirstPage {
    /Page 1 3 -1 roll
  } def
  /LastPage {
    counttomark 2 add index pdfpagecount /Page exch 3 -1 roll
  } def
  /NextPage {
    counttomark 2 add index pdfpagenumber 1 add /Page exch 3 -1 roll
  } def
  /PrevPage {
    counttomark 2 add index pdfpagenumber 1 sub /Page exch 3 -1 roll
  } def
end readonly def
% <pagedict> <annotdict> -proc- -
/annottypes 5 dict dup begin
  /Text {
    mark exch
     { /Rect /Open /Contents }
     { 2 copy knownoget { 3 -1 roll } { pop } ifelse }
    forall pop /ANN pdfmark
  } bind def
  /Link {
    mark exch
    dup /C knownoget { /Color exch 3 -1 roll } if
     { /Rect /Border }
     { 2 copy knownoget { 3 -1 roll } { pop } ifelse }
    forall dup /A knownoget {
      dup /URI known {
        /A mark 3 2 roll    % <<>> /A [ <<action>>
        { oforce } forall
        .dicttomark
        3 2 roll
      } {
        dup /D knownoget {
	  exch pop exch dup length dict copy dup /Dest 4 -1 roll put
        } {
	  /N knownoget {		% Assume /S /Named
	     namedactions exch .knownget { exec } if
	  } if
        } ifelse
      } ifelse
    } if
    linkdest pop /LNK pdfmark
  } bind def
end readonly def

% **** The following procedure should not be changed to allow clients
% **** to directly interface with the constituent procedures. GSview
% **** and some Artifex customers rely on the pdfshowpage_init,
% **** pdfshowpage_setpage, pdfshowpage_finish so all logic should be
% **** implemented in one of those three procedures.
/pdfshowpage		% <pagedict> pdfshowpage -
 { dup /Page exch store
   pdfshowpage_init 
   pdfshowpage_setpage 
   pdfshowpage_finish
 } bind def

/pdfpagecontents	% <pagedict> pdfpagecontents <contents>
 { } bind def

/pdfshowpage_init 	% <pagedict> pdfshowpage_init <pagedict>
 { /DSCPageCount DSCPageCount 1 add store
 } bind def

/.pdfshowpage_Install {	% <pagedict> [<prevproc>] .pdfshowpage_Install -
  exch
	% We would like to clip to the CropBox here, but the subsequent
	% initgraphics would override it.  Instead, we have to handle it
	% in graphicsbeginpage.
  dup /CropBox pget dup {exch pop} if systemdict /UseCropBox known and {
    dup /CropBox pget pop
  } {
    dup /MediaBox pget pop	% There has to be a MediaBox
  } ifelse
  % stack: [<prevproc>] <pagedict> <Crop|Media Box>
  exch pop oforce_array normrect		% done with the pagedict
  systemdict /PDFFitPage known {
    PDFDEBUG { (Fiting PDF to imageable area of the page.) = flush } if
    currentpagedevice /.HWMargins get aload pop
    currentpagedevice /PageSize get aload pop
    3 -1 roll sub 3 1 roll exch sub exch
    % stack: [<prevproc>] <pagedict> <Crop|Media Box> Xmin Ymin Xmax Ymax
    PDFDEBUG { (    Translate up by [ ) print 3 index =print (, ) print 2 index =print ( ]) = flush } if
    3 index 3 index translate		% move origin up to imageable area
    2 index sub exch 3 index sub exch 4 2 roll pop pop
	    % stack: [Box] XImageable YImageable
    2 index aload pop 2 index sub exch 3 index sub exch 4 2 roll pop pop
	    % stack: [Box] XImageable YImageable XBox YBox
    3 -1 roll exch div 3 1 roll div .min
    PDFDEBUG { (    Scale by ) print dup = flush } if
    dup scale
  } if
  % Now translate to the origin given in the Crop|Media Box
  dup 0 get neg exch 1 get neg translate
  0 get
  exec
} bind def

/pdfshowpage_setpage {	% <pagedict> pdfshowpage_setpage <pagedict>
  5 dict begin		% for setpagedevice
	% Stack: pagedict
  % UseCIEColor is always true for PDF; see the comment in runpdf above
  /UseCIEColor true def
  currentpagedevice /Orientation 2 index /Rotate pget not { 0 } if 90 idiv
	% Rotate specifies *clockwise* rotation!
    neg 3 and def
	% Stack: pagedict currentpagedict
  1 index /CropBox pget dup {exch pop} if systemdict /UseCropBox known and {
			% Set the page size.
    1 index /CropBox pget pop oforce_elems normrect_elems boxrect
    2 array astore /PageSize exch def pop pop
  } {
    1 index /MediaBox pget {
			% Set the page size.
      oforce_elems normrect_elems boxrect
      2 array astore /PageSize exch def pop pop
    } if
  } ifelse
  % Don't change the page size if we are going to fit the PDF to the page
  systemdict /PDFFitPage known { currentdict /PageSize undef } if
  % Let the device know if we will be using PDF 1.4 transparency.
  % The clist logic may need to adjust the size of bands.
  1 index pageusestransparency /PageUsesTransparency exch def
  dup /Install .knownget {
			% Don't let the Install procedure get more deeply
			% nested after every page.
      dup type dup /arraytype eq exch /packedarraytype eq or {
	dup length 4 eq {
	  dup 2 get /.pdfshowpage_Install load eq {
	    1 get 0 get	% previous procedure
	  } if
	} if
      } if
  } {
    { }
  } ifelse 1 array astore
  2 index exch /.pdfshowpage_Install load /exec load
  4 packedarray cvx
	% Stack: pagedict currentpagedict installproc
  /Install exch def
	% Stack: pagedict currentpagedict
  pop currentdict end setpagedevice
} bind def

/pdfshowpage_finish {	% <pagedict> pdfshowpage_finish -
   save /PDFSave exch store
   /PDFdictstackcount countdictstack store
   (before exec) VMDEBUG

   % set up color space substitution (this must be inside the page save)
   pdfshowpage_setcspacesub

  .writepdfmarks {

	% Copy the crop box.
    dup /CropBox knownoget {
      oforce_array normrect

        % .pdfshowpage_Install translates the origin -
        % do same here with the CropBox.

      1 index /CropBox pget dup {exch pop} if systemdict /UseCropBox known and {
        1 index /CropBox pget pop
      } {
        1 index /MediaBox pget pop	% There has to be a MediaBox
      } ifelse
      oforce_array normrect
      dup 0 get exch 1 get   % [] tx ty
      2 index 0 get 2 index sub 3 index exch 0 exch put
      2 index 2 get 2 index sub 3 index exch 2 exch put
      2 index 1 get 1 index sub 3 index exch 1 exch put
      2 index 3 get 1 index sub 3 index exch 3 exch put
      pop pop

	% If the page has been rotated, rotate the CropBox.
      mark /CropBox 3 -1 roll
      3 index /Rotate pget {
	90 idiv 1 and 0 ne {
	  aload pop 4 -2 roll exch 4 2 roll exch 4 array astore
	} if
      } if
      /PAGE pdfmark
    } if

	% Copy annotations and links.
    dup /Annots knownoget {
      0 1 2 index length 1 sub
       { 1 index exch oget
         dup /Subtype oget annottypes exch .knownget { exec } { pop } ifelse
       }
      for pop
    } if

  } if		% end .writepdfmarks

	% Display the actual page contents.
   6 dict begin
   /BXlevel 0 def
   /BGDefault currentblackgeneration def
   /UCRDefault currentundercolorremoval def
	%****** DOESN'T HANDLE COLOR TRANSFER YET ******
   /TRDefault currenttransfer def
  matrix currentmatrix 2 dict
  2 index /CropBox knownoget {
    oforce_elems normrect_elems boxrect
    4 array astore 1 index /ClipRect 3 -1 roll put
  } if
  dictbeginpage setmatrix
  /DefaultQstate qstate store

  count 1 sub /pdfemptycount exch store
	% If the page uses any transparency features, show it within
	% a transparency group.
  dup pageusestransparency dup /PDFusingtransparency exch def {
    % Show the page within a PDF 1.4 device filter.
    0 .pushpdf14devicefilter {
      /DefaultQstate qstate store		% device has changed -- reset DefaultQstate
      % If the page has a Group, enclose contents in transparency group.
      % (Adobe Tech Note 5407, sec 9.2)
      dup /Group knownoget {
	1 index /CropBox knownoget not {
	  1 index /MediaBox pget pop
	} if oforce_array normrect .beginformgroup {
	  showpagecontents
	} stopped {
	  .discardtransparencygroup stop
	} if .endtransparencygroup
      } {
	showpagecontents
      } ifelse
    } stopped {
      % todo: discard
      .poppdf14devicefilter 
      /DefaultQstate qstate store	% device has changed -- reset DefaultQstate
      stop
    } if .poppdf14devicefilter
    /DefaultQstate qstate store	% device has changed -- reset DefaultQstate
  } {
    showpagecontents
  } ifelse
  % todo: mixing drawing ops outside the device filter could cause
  % problems, for example with the pnga device.
  endpage
  end			% scratch dict
  % Some PDF files don't have matching q/Q (gsave/grestore) so we need
  % to clean up any left over dicts from the dictstack
  countdictstack PDFdictstackcount sub dup 0 ne { 
    (   **** Warning: File has imbalanced q/Q operators \(too many q's\)\n)
    pdfformaterror
    { end } repeat
  } {
    pop
  } ifelse
  (after exec) VMDEBUG
  Repaired		% pass Repaired state around the restore
  PDFSave restore
  /Repaired exch def
} bind def

% Display the contents of a page (including annotations).
/showpagecontents {	% <pagedict> showpagecontents -
  dup		% Save the pagedict for the Annotations
  count 1 sub  /pdfemptycount exch store
  gsave		% preserve gstate for Annotations later
  /Contents knownoget not { 0 array } if
  dup type /arraytype ne { 1 array astore } if {
    oforce false resolvestream pdfopdict .pdfrun
  } forall
  % check for extra garbage on the ostack and clean it up
  count pdfemptycount sub dup 0 ne {
    (   **** File did not complete the page properly and may be damaged.\n)
    pdfformaterror
    { pop } repeat
  } {
    pop
  } ifelse
  grestore
  % Draw the annotations
  /Annots knownoget { { oforce drawannot } forall } if
} bind def

/processcolorspace {	% - processcolorspace <colorspace>
	% The following is per the PLRM3.
  currentdevice 1 dict dup /ProcessColorModel dup put .getdeviceparams
  exch pop exch pop
  dup type /nametype ne { cvn } if
  dup { setcolorspace } .internalstopped { pop /DeviceRGB } if
} bind def

% ------ Transparency support ------ %

% Define minimum PDF version for checking for transparency features.
% Transparency is a 1.4 feature however we have seen files that claimed
% to be PDF 1.3 with transparency features.
/PDFtransparencyversion 1.3 def

% Determine whether a page might invoke any transparency features:
%	- Non-default BM, ca, CA, or SMask in an ExtGState
%	- Image XObject with SMask
% Note: we deliberately don't check to see whether a Group is defined,
% because Adobe Illustrator 10 (and possibly other applications) define
% a page-level group whether transparency is actually used or not.
% Ignoring the presence of Group is justified because, in the absence
% of any other transparency features, they have no effect.
/pageusestransparency {		% <pagedict> pageusestransparency <bool>
  PDFversion PDFtransparencyversion lt NOTRANSPARENCY or {
    pop false
  } {
    dup false exch {
      4 dict 1 index resourceusestransparency { pop not exit } if
      /Parent knownoget not { exit } if
    } loop
    % Also check for transparency in the annotation (if not in resources).
    { pop true } { annotsusetransparency } ifelse
  } ifelse
} bind def

% Check if transparency is specified in an ExtGState dict
/extgstateusestransparency {	% <gstate dict> extgstateusestransparency <bool>
  false exch		% Assume no transparency
  {			% establish loop context
    exch pop oforce
    dup /BM knownoget { dup /Normal ne exch /Compatible ne and
	                    { pop not exit } if
                          } if
    dup /ca knownoget { 1 ne { pop not exit } if } if
    dup /CA knownoget { 1 ne { pop not exit } if } if
    dup /SMask knownoget { /None ne { pop not exit } if } if
    pop
  } forall
} bind def

% Check the Resources of a page or Form. Check for loops in the resource chain.
/resourceusestransparency {	% <dict> <dict> resourceusestransparency <bool>
  {	% Use loop to provide an exitable context.
    /Resources knownoget not { 0 dict } if
    2 copy known {
      (   **** File has circular references in resource dictionaries.\n)
      pdfformaterror
      pop false exit
    } if
    2 copy dup put
    dup /ExtGState knownoget {
      extgstateusestransparency
      { pop true exit } if
    } if
    dup /XObject knownoget {
      false exch {
	exch pop oforce dup /Subtype get
	dup /Image eq { 1 index /SMask known { pop pop not exit } if } if
	/Form eq {
	  3 index exch resourceusestransparency { not exit } if
	} {
	  pop
	} ifelse
      } forall { pop true exit } if
    } if
    pop false exit
  } loop
  exch pop
} bind def

% Check if the annotations on a page use transparency
/annotsusetransparency {	% <page dict> annotsusetransparency <bool>
   false exch			% Assume no transparency
   /Annots knownoget {		% Get Annots array
     { oforce /AP knownoget {	% Get appearance dict for the annoation
         /N oget		% Get the /N (i.e. normal) appearance stream
	 /Resources knownoget {
	   /ExtGState knownoget {
	     extgstateusestransparency { pop true exit} if
	   } if			% If ExtGState known
	 } if			% If Resources known
       } if			% If AP dict known
     } forall			% For all annots on the page
   } if
} bind def

% ------ ColorSpace substitution support ------ %

%
%  <pagedict>   pdfshowpage_setcspacesub   <pagedict>
%
% Set up color space substitution for a page. Invocations of this procedure
% must be bracketed by the save/restore operation for the page, to avoid
% unintended effects on other pages.
%
% If any color space substitution is used, and the current color space is a
% device dependent color space, make sure the current color space is updated.
% There is an optimization in the setcolorspace pseudo-operator that does
% nothing if both the current and operand color spaces are the same. For
% PostScript this optimization is disabled if the UseCIEColor page device
% parameter is true. This is not the case for PDF, as performance suffers
% significantly on some PDF files if color spaces are set repeatedly. Hence,
% if color space substitution is to be used, and the current color space
% is a device dependent color space, we must make sure to "transition" the
% current color space.
%
/pdfshowpage_setcspacesub
  {
    false
      { /DefaultGray /DefaultRGB /DefaultCMYK }
      {
        dup 3 index /ColorSpace //rget exec
          { resolvecolorspace /ColorSpace defineresource pop }
          { pop }
        ifelse
      }
    forall

    % if using color space substitution, "transition" the current color space
      {
        currentcolorspace dup length 1 eq   % always an array
          {
            0 get
            dup /DeviceGray eq 1 index /DeviceRGB eq or 1 index /DeviceCMYK or
              { /Pattern setcolorspace setcolorspace }
              { pop }
            ifelse
          }
          { pop }
        if
      }
    if
  }
bind def



end			% pdfdict
.setglobal
